package Day003_多态_内部类.demo005引用类型转换;

/*
    引用类型转换:(父子类或实现关系)
                1.向上转型:
                        子类类型向父类类型向上转换的过程,自动的
                        格式: 父类类型 对象名 = 子类对象;
                        Animal anl = new Cat();
                2.向下转型:
                        父类类型向子类类型向下转换的过程,强制的
                        格式: 子类类型 对象名 = (子类类型)父类对象
                        Cat cat = (Cat) new Animal();

                3.instanceof 关键字 ---> 判断
                         直接向下转型解决多态弊端,可能会出现类型转换异常
                            对象名 instanceof 数据类型
                            如果变量属于该数据类型 返回true
                            如果变量不属于该数据类型 返回false
                            if (变量名 instanceof 数据类型){
                            }

 */

public class Test {
    public static void main(String[] args) {

        //1.向上转型  子类类型 --> 父类类型
        //自动
        Animal anl = new Cat();

        //2.向下转型  父类类型 --> 子类类型
        //强转
        //Cat cat = new Animal();编译报错
        //Cat cat = (Cat) new Animal();

        //3.多态弊端 不能访问子类独有
        //Animal anl = new Cat();
        //anl.eat();
        //System.out.println(anl2.num); 编译报错
        //anl2.catchMouse(); 编译报错

        System.out.println("----解决弊端----");

        //Cat cat = (Cat)anl; //向下转型,欺骗编译器 告诉它anl不是Animal类型,是Cat类型
        //System.out.println(((Cat) anl).num);
        //((Cat) anl).catchMouse();

        System.out.println("直接向下转型解决多态的弊端,可能会出现类型转换异常=====");

        // 如果在转型的前面,anl又指向了其他Animal类的子类对象
        anl = new Dog();
        // 解决: 先判断,再转型--->更加安全
    }

    public static void method(Animal anl) {// 可能会传狗对象,可能会传猫对象

        anl.eat();

        if (anl instanceof Cat) {
            Cat cat = (Cat) anl;
            cat.catchMouse();
        }

        if (anl instanceof Dog) {
            Dog dog = (Dog) anl;
            dog.lookHome();
        }
        //anl.catchMouse();//编译报错 访问猫对象的独有方法
        //anl.lookHome();//编译报错 访问狗对象的独有方法
    }

}

